# Extended Pseudocode for an SME Intelligent Brain Platform based on ChatGLM + Multi-Agent System
# This extended version includes detailed modules for semantic parsing, multi-agent collaboration,
# session management, logging, metrics tracking, and advanced feedback learning.

import time
import random
import uuid
import logging

# === GLOBAL LOGGING SETUP ===
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# === SIMULATED MODELS AND APIs ===
class ChatGLM:
    def __init__(self, model_path):
        self.model_path = model_path

    def parse(self, text):
        return {"intent": "QUERY_POLICY", "entities": ["reimbursement"]}

    def generate_response(self, context):
        return f"Generated answer for: {context}"

    def fine_tune(self, data):
        logging.info("Fine-tuning model with user feedback...")


class KnowledgeGraph:
    def query(self, entity):
        return f"Information about {entity} from KG."

    def add_entity(self, entity, info):
        logging.info(f"Entity {entity} added with info: {info}")


# === AGENT FRAMEWORK ===
class Agent:
    def __init__(self, agent_id, role, skills):
        self.agent_id = agent_id
        self.role = role
        self.skills = skills
        self.status = "idle"
        self.task = None

    def assign_task(self, task):
        self.task = task
        self.status = "busy"
        self.execute_task()

    def execute_task(self):
        time.sleep(random.uniform(0.1, 0.4))
        logging.info(f"{self.agent_id} executed task: {self.task}")
        self.status = "idle"
        self.task = None

    def get_status(self):
        return self.status


# === SESSION AND TASK MANAGEMENT ===
class SessionManager:
    def __init__(self):
        self.sessions = {}

    def create_session(self, user_id):
        session_id = f"session_{uuid.uuid4()}"
        self.sessions[user_id] = session_id
        return session_id

    def get_session(self, user_id):
        return self.sessions.get(user_id, self.create_session(user_id))


class TaskManager:
    def __init__(self):
        self.task_queue = []

    def decompose_intent(self, intent_data):
        tasks = []
        if intent_data["intent"] == "QUERY_POLICY":
            for entity in intent_data["entities"]:
                tasks.append({"type": "KG_QUERY", "entity": entity})
        return tasks


# === DISPATCH AND MONITORING ===
class Dispatcher:
    def __init__(self, agents):
        self.agents = agents

    def dispatch(self, task):
        idle_agents = [a for a in self.agents if a.status == "idle" and a.role == task["type"]]
        if idle_agents:
            selected = idle_agents[0]
            selected.assign_task(task)
        else:
            logging.warning("No idle agents. Task will be queued.")


class MetricsLogger:
    def __init__(self):
        self.records = []

    def log_event(self, session_id, event_type, detail):
        log_entry = {
            "session_id": session_id,
            "event_type": event_type,
            "detail": detail,
            "timestamp": time.time()
        }
        self.records.append(log_entry)
        logging.info(f"Logged event: {event_type} - {detail}")


# === FEEDBACK AND LEARNING ===
class FeedbackEngine:
    def __init__(self):
        self.feedback_data = []

    def record_feedback(self, session_id, task_result, score):
        feedback = {
            "session": session_id,
            "result": task_result,
            "score": score
        }
        self.feedback_data.append(feedback)
        logging.info(f"Feedback recorded: {feedback}")

    def evaluate(self):
        return [f for f in self.feedback_data if f["score"] < 3]


# === PLATFORM CONTROLLER ===
class EnterpriseBrainPlatform:
    def __init__(self):
        self.model = ChatGLM("/models/chatglm-finetuned")
        self.kg = KnowledgeGraph()
        self.session_manager = SessionManager()
        self.task_manager = TaskManager()
        self.metrics_logger = MetricsLogger()
        self.feedback_engine = FeedbackEngine()
        self.agents = [
            Agent("A001", "KG_QUERY", ["policy", "finance"]),
            Agent("A002", "CHAT_RESPONSE", ["general"]),
            Agent("A003", "WORKFLOW_CALL", ["approval"])
        ]
        self.dispatcher = Dispatcher(self.agents)

    def process_user_input(self, user_id, text):
        session_id = self.session_manager.get_session(user_id)
        self.metrics_logger.log_event(session_id, "user_input", text)

        intent_data = self.model.parse(text)
        subtasks = self.task_manager.decompose_intent(intent_data)

        for task in subtasks:
            self.dispatcher.dispatch(task)
            self.metrics_logger.log_event(session_id, "task_dispatched", task)

    def collect_user_feedback(self, session_id, rating):
        self.feedback_engine.record_feedback(session_id, "response_output", rating)

    def retrain_model_if_needed(self):
        poor_feedbacks = self.feedback_engine.evaluate()
        if poor_feedbacks:
            self.model.fine_tune(poor_feedbacks)


# === SIMULATION ===
if __name__ == "__main__":
    platform = EnterpriseBrainPlatform()

    users_inputs = [
        ("user_1", "What is the reimbursement policy?"),
        ("user_2", "How to apply for leave?"),
        ("user_3", "I want to know expense guidelines")
    ]

    for user_id, text in users_inputs:
        platform.process_user_input(user_id, text)

    for i in range(3):
        platform.collect_user_feedback(f"session_{i}", random.randint(1, 5))

    platform.retrain_model_if_needed()
    print("=== SME Intelligent Brain Platform Execution Completed ===")
